package com.Sun.Helper;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.LinkedBlockingQueue;

import com.Sun.DB.DBHelper;
import com.Sun.Model.encryptedIndex;
import com.Sun.Model.indexTreeNode;
import com.Sun.index.indexEncrypted;
import com.Sun.index.indexHelper;


public class buildIndexTreeHelper {
	public static Queue<indexTreeNode> getallLeafIndexTree(List<String> fidList)
	{
		Queue<indexTreeNode> resultQueue=new LinkedBlockingQueue<indexTreeNode>();
		Iterator<String> iterator=fidList.iterator();
		while(iterator.hasNext())
		{
			String fid=iterator.next();
			indexTreeNode tempIndexNode=getNewLeafIndexTree(fid);
			resultQueue.add(tempIndexNode);
		}
		return resultQueue;
	}
	public static indexTreeNode getNewLeafIndexTree(String fid)
	{
		indexTreeNode resultNode=new indexTreeNode();
		List<String> wordList=DBHelper.getWordList(fid);
		double []searchIndex=indexHelper.getSearchPlainIndex(fid);//得到每个文件对应的明文索引向量
	    Iterator<String>iterator=wordList.iterator();
	    resultNode.setSearchIndex(searchIndex);
	    resultNode.setFID(fid);
		return resultNode;
	}
	public static List<indexTreeNode> getAllBuildTreeNode(indexTreeNode root)
	{
		List<indexTreeNode> resultList=new ArrayList<indexTreeNode>();
		Queue<indexTreeNode> queue=new LinkedBlockingQueue<indexTreeNode>();
		indexTreeNode currNode=root;
		if(currNode!=null)
		{
			queue.add(currNode);
		}
		while(!queue.isEmpty())
		{
			indexTreeNode tempNode=queue.peek();
			resultList.add(tempNode);
			if(tempNode.getLeft()!=null)
			{
				queue.add(tempNode.getLeft());
			}
			if(tempNode.getRight()!=null)
			{
				queue.add(tempNode.getRight());
			}
			
		}
		return resultList;
		
	}
	/**
	 *  加密索引树中节点信息
	 * @param root
	 * @param inSK
	 */
	public static void encrypteTreeNode(indexTreeNode root,indexEncrypted inSK) 
	{
		indexTreeNode currNode=root;
		Queue<indexTreeNode> queue=new LinkedBlockingQueue<indexTreeNode>();
		if(currNode!=null)
		{
			queue.add(currNode);
		}
		while(!queue.isEmpty())
		{
			currNode=queue.poll();
			encryptedIndex tempEnIndex=inSK.IndexEncrypted(currNode.getSearchIndex());
			currNode.setEnIndex(tempEnIndex);
			//currNode.setSearchIndex(null);//设置节点的加密索引并将明文索引向量设置为空
			if(currNode.getLeft()!=null)
			{
				queue.add(currNode.getLeft());
			}
			if(currNode.getRight()!=null)
			{
				queue.add(currNode.getRight());
			}	
		}
	}
//	/**
//	 * 加密索引树的中间节点
//	 * @param root
//	 * @param sk
//	 */
//	public static void encryptInternalNode(indexTreeNode root,int sk)
//	{
//		int n=indexHelper.wordDisCount;
//		int encyptKeyword[]=new int[n];
//		indexTreeNode currNode=root;
//		Queue<indexTreeNode> queue=new LinkedBlockingQueue<indexTreeNode>();
//		for(int i=0;i<n;i++)
//		{
//			encyptKeyword[i]=encryptHelper.F(sk, indexHelper.wordList.get(i));
//		}
//		if(root!=null)
//		{
//			queue.add(currNode);
//		}
//		while(!queue.isEmpty())
//		{
//			currNode=queue.poll();
//			if(!(currNode.getLeft()==null&&currNode.getRight()==null))
//			{
//				int len=currNode.getSearchIndex().length;
//				int []tempIndex=new int[len];
//				for(int i=0;i<len;i++)
//				{
//					String tempEnKeyword=Integer.toString(encyptKeyword[i]);
//					tempIndex[i]=encryptHelper.U(tempEnKeyword, currNode.getSearchIndex()[i]);
//				}
//				currNode.setSearchIndex(tempIndex);
//			}
//			if(currNode.getLeft()!=null)
//			{
//				queue.add(currNode.getLeft());
//			}
//			if(currNode.getRight()!=null)
//			{
//				queue.add(currNode.getRight());
//			}	
//		}
//	}
	
}
